package jvm规范;

public class Benchmark自助性能测试 {

}
1、前言
在日常开发中，我们对一些代码的调用或者工具的使用会存在多种选择方式，在不确定他们性能的时候，我们首先想要做的就是去测量它。大多数时候，我们会
简单的采用多次计数的方式来测量，来看这个方法的总耗时。

但是，如果熟悉JVM类加载机制的话，应该知道JVM默认的执行模式是JIT编译与解释混合执行。JVM通过热点代码统计分析，识别高频方法的调用、循环体、公
共模块等，基于JIT动态编译技术，会将热点代码转换成机器码，直接交给CPU执行。



也就是说，JVM会不断的进行编译优化，这就使得很难确定重复多少次才能得到一个稳定的测试结果？所以，很多有经验的同学会在测试代码前写一段预热的逻辑。

JMH，全称 Java Microbenchmark Harness (微基准测试框架），是专门用于Java代码微基准测试的一套测试工具API，是由 OpenJDK/Oracle官
方发布的工具。何谓 Micro Benchmark 呢？ 简单地说就是在 method 层面上的 benchmark，精度可以精确到微秒级。

Java的基准测试需要注意的几个点：

·测试前需要预热。
·防止无用代码进入测试方法中。
·并发测试。
·测试结果呈现。

JMH的使用场景：

1)定量分析某个热点函数的优化效果
2)想定量地知道某个函数需要执行多长时间，以及执行时间和输入变量的相关性
3)对比一个函数的多种实现方式

2、开始前的步骤
项目使用的是 Maven，因此只要对 pom.xml 添加依赖即可。

<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.19</version>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.19</version>
    <scope>provided</scope>
</dependency>
3、例子
记得之前和宿友讨论 ArrayList 和 LinkedList 的遍历的性能差别，当时以一种不太妥当的方法进行测试，导致无法得到比较好的结果，刚好这里可以使用这两个来进行比较。

4、代码
4.1 创建业务服务类
 
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
 
//业务服务类
public class BizService {
    private int n = 10000;
    private List<Integer> arrayList;
    private List<Integer> linkedList;
 
    public BizService () {
        arrayList = new ArrayList<>(0);
        linkedList = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }
    }
 
    //扫描array集合，待测试的方法1
    public void scanArray() {
        for (int i = 0; i < n; i++) {
            this.arrayList.get(i);
        }
    }
 
    //扫描list集合，待测试的方法2
    public void scanList() {
        for (int i = 0; i < n; i++) {
            this.linkedList.get(i);
        }
    }
 
    //清空数据
    public void clear() {
        for (int i = 0; i < n; i++) {
            this.arrayList.remove(0);
            this.linkedList.remove(0);
        }
    }
}
4.2 创建性能测试代码
package com.wenxiaowu.jmh;
 
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
 
import java.util.concurrent.TimeUnit;
 
@BenchmarkMode(Mode.Throughput) // 吞吐量
@OutputTimeUnit(TimeUnit.MILLISECONDS) // 结果所使用的时间单位
@State(Scope.Thread) // 每个测试线程分配一个实例
@Fork(2) // Fork进行的数目
@Warmup(iterations = 1) // 先预热1轮
@Measurement(iterations = 2) // 进行2轮测试
public class JmhMainApplication {
    BizService bizService;
 
    @Setup(Level.Trial) // 初始化方法，在全部Benchmark运行之前进行
    public void init() {
        bizService = new BizService();
    }
 
    @Benchmark
    public void arrayTraverse() {
        bizService.scanArray();
    }
 
    @Benchmark
    public void listTraverse() {
        bizService.scanList();
    }
 
    @TearDown(Level.Trial) // 结束方法，在全部Benchmark运行之后进行
    public void arrayRemove() {
        bizService.clear();
    }
 
    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder().include(JmhMainApplication.class.getSimpleName()).build();
        new Runner(options).run();
    }
}
 最终执行的效果
/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/bin/java "-javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=57755:/Applications/IntelliJ IDEA.app/Contents/bin" -Dfile.encoding=UTF-8 -classpath /Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/charsets.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/deploy.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/cldrdata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/dnsns.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/jaccess.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/jfxrt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/localedata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/nashorn.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/sunec.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/sunjce_provider.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/sunpkcs11.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/ext/zipfs.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/javaws.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/jce.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/jfr.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/jfxswt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/jsse.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/management-agent.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/plugin.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/resources.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/lib/rt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/lib/ant-javafx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/lib/dt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/lib/javafx-mx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/lib/jconsole.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/lib/packager.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/lib/sa-jdi.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/lib/tools.jar:/Users/yangbin/Documents/workspace/wenxiaowu-java/wenxiaowu-jmh-test/target/classes:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-starter-web/2.3.1.RELEASE/spring-boot-starter-web-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-starter/2.3.1.RELEASE/spring-boot-starter-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot/2.3.1.RELEASE/spring-boot-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-autoconfigure/2.3.1.RELEASE/spring-boot-autoconfigure-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-starter-logging/2.3.1.RELEASE/spring-boot-starter-logging-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar:/Users/yangbin/.m2/repository/ch/qos/logback/logback-core/1.2.3/logback-core-1.2.3.jar:/Users/yangbin/.m2/repository/org/apache/logging/log4j/log4j-to-slf4j/2.13.3/log4j-to-slf4j-2.13.3.jar:/Users/yangbin/.m2/repository/org/apache/logging/log4j/log4j-api/2.13.3/log4j-api-2.13.3.jar:/Users/yangbin/.m2/repository/org/slf4j/jul-to-slf4j/1.7.30/jul-to-slf4j-1.7.30.jar:/Users/yangbin/.m2/repository/jakarta/annotation/jakarta.annotation-api/1.3.5/jakarta.annotation-api-1.3.5.jar:/Users/yangbin/.m2/repository/org/yaml/snakeyaml/1.26/snakeyaml-1.26.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-starter-json/2.3.1.RELEASE/spring-boot-starter-json-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/com/fasterxml/jackson/core/jackson-databind/2.11.0/jackson-databind-2.11.0.jar:/Users/yangbin/.m2/repository/com/fasterxml/jackson/core/jackson-annotations/2.11.0/jackson-annotations-2.11.0.jar:/Users/yangbin/.m2/repository/com/fasterxml/jackson/core/jackson-core/2.11.0/jackson-core-2.11.0.jar:/Users/yangbin/.m2/repository/com/fasterxml/jackson/datatype/jackson-datatype-jdk8/2.11.0/jackson-datatype-jdk8-2.11.0.jar:/Users/yangbin/.m2/repository/com/fasterxml/jackson/datatype/jackson-datatype-jsr310/2.11.0/jackson-datatype-jsr310-2.11.0.jar:/Users/yangbin/.m2/repository/com/fasterxml/jackson/module/jackson-module-parameter-names/2.11.0/jackson-module-parameter-names-2.11.0.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-starter-tomcat/2.3.1.RELEASE/spring-boot-starter-tomcat-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/org/apache/tomcat/embed/tomcat-embed-core/9.0.36/tomcat-embed-core-9.0.36.jar:/Users/yangbin/.m2/repository/org/glassfish/jakarta.el/3.0.3/jakarta.el-3.0.3.jar:/Users/yangbin/.m2/repository/org/apache/tomcat/embed/tomcat-embed-websocket/9.0.36/tomcat-embed-websocket-9.0.36.jar:/Users/yangbin/.m2/repository/org/springframework/spring-web/5.2.7.RELEASE/spring-web-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/spring-beans/5.2.7.RELEASE/spring-beans-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/spring-webmvc/5.2.7.RELEASE/spring-webmvc-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/spring-aop/5.2.7.RELEASE/spring-aop-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/spring-context/5.2.7.RELEASE/spring-context-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/spring-expression/5.2.7.RELEASE/spring-expression-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-starter-test/2.3.1.RELEASE/spring-boot-starter-test-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-test/2.3.1.RELEASE/spring-boot-test-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/boot/spring-boot-test-autoconfigure/2.3.1.RELEASE/spring-boot-test-autoconfigure-2.3.1.RELEASE.jar:/Users/yangbin/.m2/repository/com/jayway/jsonpath/json-path/2.4.0/json-path-2.4.0.jar:/Users/yangbin/.m2/repository/net/minidev/json-smart/2.3/json-smart-2.3.jar:/Users/yangbin/.m2/repository/net/minidev/accessors-smart/1.2/accessors-smart-1.2.jar:/Users/yangbin/.m2/repository/org/ow2/asm/asm/5.0.4/asm-5.0.4.jar:/Users/yangbin/.m2/repository/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar:/Users/yangbin/.m2/repository/jakarta/xml/bind/jakarta.xml.bind-api/2.3.3/jakarta.xml.bind-api-2.3.3.jar:/Users/yangbin/.m2/repository/jakarta/activation/jakarta.activation-api/1.2.2/jakarta.activation-api-1.2.2.jar:/Users/yangbin/.m2/repository/org/assertj/assertj-core/3.16.1/assertj-core-3.16.1.jar:/Users/yangbin/.m2/repository/org/hamcrest/hamcrest/2.2/hamcrest-2.2.jar:/Users/yangbin/.m2/repository/org/junit/jupiter/junit-jupiter/5.6.2/junit-jupiter-5.6.2.jar:/Users/yangbin/.m2/repository/org/junit/jupiter/junit-jupiter-api/5.6.2/junit-jupiter-api-5.6.2.jar:/Users/yangbin/.m2/repository/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar:/Users/yangbin/.m2/repository/org/junit/platform/junit-platform-commons/1.6.2/junit-platform-commons-1.6.2.jar:/Users/yangbin/.m2/repository/org/junit/jupiter/junit-jupiter-params/5.6.2/junit-jupiter-params-5.6.2.jar:/Users/yangbin/.m2/repository/org/junit/jupiter/junit-jupiter-engine/5.6.2/junit-jupiter-engine-5.6.2.jar:/Users/yangbin/.m2/repository/org/junit/vintage/junit-vintage-engine/5.6.2/junit-vintage-engine-5.6.2.jar:/Users/yangbin/.m2/repository/org/apiguardian/apiguardian-api/1.1.0/apiguardian-api-1.1.0.jar:/Users/yangbin/.m2/repository/org/junit/platform/junit-platform-engine/1.6.2/junit-platform-engine-1.6.2.jar:/Users/yangbin/.m2/repository/junit/junit/4.13/junit-4.13.jar:/Users/yangbin/.m2/repository/org/mockito/mockito-core/3.3.3/mockito-core-3.3.3.jar:/Users/yangbin/.m2/repository/net/bytebuddy/byte-buddy/1.10.11/byte-buddy-1.10.11.jar:/Users/yangbin/.m2/repository/net/bytebuddy/byte-buddy-agent/1.10.11/byte-buddy-agent-1.10.11.jar:/Users/yangbin/.m2/repository/org/objenesis/objenesis/2.6/objenesis-2.6.jar:/Users/yangbin/.m2/repository/org/mockito/mockito-junit-jupiter/3.3.3/mockito-junit-jupiter-3.3.3.jar:/Users/yangbin/.m2/repository/org/skyscreamer/jsonassert/1.5.0/jsonassert-1.5.0.jar:/Users/yangbin/.m2/repository/com/vaadin/external/google/android-json/0.0.20131108.vaadin1/android-json-0.0.20131108.vaadin1.jar:/Users/yangbin/.m2/repository/org/springframework/spring-core/5.2.7.RELEASE/spring-core-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/spring-jcl/5.2.7.RELEASE/spring-jcl-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/springframework/spring-test/5.2.7.RELEASE/spring-test-5.2.7.RELEASE.jar:/Users/yangbin/.m2/repository/org/xmlunit/xmlunit-core/2.7.0/xmlunit-core-2.7.0.jar:/Users/yangbin/.m2/repository/org/openjdk/jmh/jmh-core/1.19/jmh-core-1.19.jar:/Users/yangbin/.m2/repository/net/sf/jopt-simple/jopt-simple/4.6/jopt-simple-4.6.jar:/Users/yangbin/.m2/repository/org/apache/commons/commons-math3/3.2/commons-math3-3.2.jar com.wenxiaowu.jmh.JmhMainApplication
# JMH version: 1.19
# VM version: JDK 1.8.0_221, VM 25.221-b11
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/bin/java
# VM options: -javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=57755:/Applications/IntelliJ IDEA.app/Contents/bin -Dfile.encoding=UTF-8
# Warmup: 1 iterations, 1 s each
# Measurement: 2 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Throughput, ops/time
# Benchmark: com.wenxiaowu.jmh.JmhMainApplication.arrayTraverse
 
# Run progress: 0.00% complete, ETA 00:00:12
# Fork: 1 of 2
# Warmup Iteration   1: 218321.177 ops/ms
Iteration   1: 205126.949 ops/ms
Iteration   2: 222546.531 ops/ms
 
# Run progress: 25.00% complete, ETA 00:00:28
# Fork: 2 of 2
# Warmup Iteration   1: 220523.238 ops/ms
Iteration   1: 207016.360 ops/ms
Iteration   2: 220534.484 ops/ms
 
 
Result "com.wenxiaowu.jmh.JmhMainApplication.arrayTraverse":
  213806.081 ±(99.9%) 58169.213 ops/ms [Average]
  (min, avg, max) = (205126.949, 213806.081, 222546.531), stdev = 9001.750
  CI (99.9%): [155636.868, 271975.293] (assumes normal distribution)
 
 
# JMH version: 1.19
# VM version: JDK 1.8.0_221, VM 25.221-b11
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/jre/bin/java
# VM options: -javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=57755:/Applications/IntelliJ IDEA.app/Contents/bin -Dfile.encoding=UTF-8
# Warmup: 1 iterations, 1 s each
# Measurement: 2 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Throughput, ops/time
# Benchmark: com.wenxiaowu.jmh.JmhMainApplication.listTraverse
 
# Run progress: 50.00% complete, ETA 00:00:18
# Fork: 1 of 2
# Warmup Iteration   1: 0.018 ops/ms
Iteration   1: 0.013 ops/ms
Iteration   2: 0.018 ops/ms
 
# Run progress: 75.00% complete, ETA 00:00:09
# Fork: 2 of 2
# Warmup Iteration   1: 0.018 ops/ms
Iteration   1: 0.018 ops/ms
Iteration   2: 0.018 ops/ms
 
 
Result "com.wenxiaowu.jmh.JmhMainApplication.listTraverse":
  0.017 ±(99.9%) 0.016 ops/ms [Average]
  (min, avg, max) = (0.013, 0.017, 0.018), stdev = 0.002
  CI (99.9%): [0.001, 0.033] (assumes normal distribution)
 
 
# Run complete. Total time: 00:00:36
 
Benchmark                          Mode  Cnt       Score       Error   Units
JmhMainApplication.arrayTraverse  thrpt    4  213806.081 ± 58169.213  ops/ms
JmhMainApplication.listTraverse   thrpt    4       0.017 ±     0.016  ops/ms
 
Process finished with exit code 0

注解介绍

@BenchmarkMode	
Mode 表示 JMH 进行 Benchmark 时所使用的模式。通常是测量的维度不同，或是测量的方式不同。目前 JMH 共有四种模式：
Throughput: 整体吞吐量，例如“1秒内可以执行多少次调用”，单位是操作数/时间。
AverageTime: 调用的平均时间，例如“每次调用平均耗时xxx毫秒”，单位是时间/操作数。
SampleTime: 随机取样，最后输出取样结果的分布，例如“99%的调用在xxx毫秒以内，99.99%的调用在xxx毫秒以内”
SingleShotTime: 以上模式都是默认一次 iteration 是 1s，唯有 SingleShotTime 是只运行一次。往往同时把 warmup 次数设为0，用于测试冷启动时的性能。 

@OutputTimeUnit
输出的时间单位。

@Iteration
Iteration 是 JMH 进行测试的最小单位。在大部分模式下，一次 iteration 代表的是一秒，JMH 会在这一秒内不断调用需要 Benchmark 的方法，然后根据模式对
其采样，计算吞吐量，计算平均执行时间等。

@WarmUp
Warmup 是指在实际进行 Benchmark 前先进行预热的行为。
为什么需要预热？因为 JVM 的 JIT 机制的存在，如果某个函数被调用多次之后，JVM 会尝试将其编译成为机器码从而提高执行速度。为了让 Benchmark 的结果更加接
近真实情况就需要进行预热。

@State
类注解，JMH测试类必须使用 @State 注解，它定义了一个类实例的生命周期，可以类比 Spring Bean 的 Scope。由于 JMH 允许多线程同时执行测试，不同的选项含义如下：

Scope.Thread：默认的 State，每个测试线程分配一个实例；
Scope.Benchmark：所有测试线程共享一个实例，用于测试有状态实例在多线程共享下的性能；
Scope.Group：每个线程组共享一个实例；

@Fork
进行 fork 的次数。如果 fork 数是2的话，则 JMH 会 fork 出两个进程来进行测试。

@Meansurement
提供真正的测试阶段参数。指定迭代的次数，每次迭代的运行时间和每次迭代测试调用的数量(通常使用 @BenchmarkMode(Mode.SingleShotTime) 测试一组操作
的开销——而不使用循环)

@Setup
方法注解，会在执行 benchmark 之前被执行，正如其名，主要用于初始化。

@TearDown
方法注解，与@Setup 相对的，会在所有 benchmark 执行结束以后执行，主要用于资源的回收等。

@Setup/@TearDown注解使用Level参数来指定何时调用fixture：

| 名称 | 描述 |
| - | :-: | -: |
| Level.Trial      | 默认level。全部benchmark运行(一组迭代)之前/之后      |
| Level.Iteration  | 一次迭代之前/之后（一组调用)                        |
| Level.Invocation | 每个方法调用之前/之后(不推荐使用，除非你清楚这样做的目的)  |

@Benchmark
方法注解，表示该方法是需要进行 benchmark 的对象。

@Param
成员注解，可以用来指定某项参数的多种情况。特别适合用来测试一个函数在不同的参数输入的情况下的性能。@Param 注解接收一个String数组，在 @Setup 方法执行
前转化为为对应的数据类型。多个 @Param 注解的成员之间是乘积关系，譬如有两个用 @Param 注解的字段，第一个有5个值，第二个字段有2个值，那么每个测试方法
会跑5*2=10次。




什么是JMH
JMH 是 OpenJDK 团队开发的一款基准测试工具，一般用于代码的性能调优，精度甚至可以达到纳秒级别，适用于 java 以及其他基于 JVM 的语言。和 Apache JMeter 不同，JMH 测试的对象可以是任一方法，颗粒度更小，而不仅限于rest api。

使用时，我们只需要通过配置告诉 JMH 测试哪些方法以及如何测试，JMH 就可以为我们自动生成基准测试的代码。

JMH生成基准测试代码的原理
我们只需要通过配置（主要是注解）告诉 JMH 测试哪些方法以及如何测试，JMH 就可以为我们自动生成基准测试的代码。

那么 JMH 是如何做到的呢？

要使用 JMH，我们的 JMH 配置项目必须是 maven 项目。在一个 JMH配置项目中，我们可以在pom.xml看到以下配置。JMH 自动生成基准测试代码的本质就是使用 maven 插件的方式，在 package 阶段对配置项目进行解析和包装。

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <finalName>${uberjar.name}</finalName>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>org.openjdk.jmh.Main</mainClass>
                                </transformer>
                            </transformers>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
从入门例子开始
下面会先介绍整个使用流程，再通过一个入门例子来演示如何使用 JMH。

步骤
如果我有一个 A 项目，我希望对这个项目里的某些方法进行 JMH 测试，可以这么做：

创建单独的 JMH 配置项目B。
新建一个独立的配置项目 B（建议使用 archetype 生成，可以确保配置正确），B 依赖了 A。

当然，我们也可以直接将项目 A 作为 JMH 配置项目，但这样做会导致 JMH 渗透到 A 项目中，所以，最好不要这么做。

配置项目B。
在 B 项目里面，我们可以使用 JMH 的注解或对象来指定测试哪些方法以及如何测试，等等。

构建和运行。
在正确配置 pom.xml 的前提下，使用 mvn 命令打包 B 项目，JMH 会为我们自动生成基准测试代码，并单独打包成 benchmarks.jar。运行 benchmarks.jar，基准测试就可以跑起来了。

注意，JMH 也支持使用 Java API 的方式来运行，但官方并不推荐，所以，本文也不会介绍。

下面开始入门例子。

项目环境说明
maven：3.6.3

操作系统：win10

JDK：8u231

JMH：1.25

创建 JMH 配置项目
为了保证配置的正确性，建议使用 archetype 生成 JMH 配置项目。cmd 运行下面这段代码：

mvn archetype:generate ^
-DinteractiveMode=false ^
-DarchetypeGroupId=org.openjdk.jmh ^
-DarchetypeArtifactId=jmh-java-benchmark-archetype ^
-DarchetypeVersion=1.25 ^
-DgroupId=cn.zzs.jmh ^
-DartifactId=jmh-test01 ^
-Dversion=1.0.0
注：如果使用 linux，请将“^”替代为“\”。

命令执行后，在当前目录下生成了一个 maven 项目，如下。这个项目就是本文说到的 JMH 配置项目。这里 archetype 还提供了一个例子MyBenchmark。

└─jmh-test01
    │  pom.xml
    │
    └─src
        └─main
            └─java
                └─cn
                    └─zzs
                        └─jmh
                                MyBenchmark.java
配置 JMH 配置项目
配置 pom.xml
因为是使用 archetype 生成的项目，所以pom.xml 文件已经包含了比较完整的 JMH 配置，如下(省略部分)。如果自己手动创建配置项目，则需要拷贝下面这些内容。

<dependencies>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-core</artifactId>
            <version>${jmh.version}</version>
        </dependency>
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>${jmh.version}</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jmh.version>1.25</jmh.version>
        <javac.target>1.8</javac.target>
        <uberjar.name>benchmarks</uberjar.name>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <finalName>${uberjar.name}</finalName>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>org.openjdk.jmh.Main</mainClass>
                                </transformer>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                            </transformers>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
配置Benchmark方法
项目里的 MyBenchmark 类就是一个简单的示例，testMethod 方法就是一个 Benchmark 方法。我们可以直接在 testMethod 方法中编写测试代码，也可以调用父项目的方法。

testMethod 方法上加了@Benchmark注解，@Benchmark注解用来告诉 JMH 在 mvn package 时生成这个方法的基准测试代码。

当然，我们还可以增加其他的配置来影响 JMH 如何生成基准测试代码，这里暂时不展开。

package cn.zzs.jmh;

import org.openjdk.jmh.annotations.Benchmark;

public class MyBenchmark {

    @Benchmark
    public void testMethod() {
        // place your benchmarked code here
    }

}
打包和运行
分别运行以下命令，完成对项目的打包：

cd jmh-test01
mvn clean package
这时，target 目录下，不仅生成了项目本身的 jar 包，还生成了一个 benchmarks.jar。这个包就是 JMH 为我们生成的基准测试代码。

└─jmh-test01
    │  pom.xml
    │
    ├─src
    │  └─main
    │      └─java
    │          └─cn
    │              └─zzs
    │                  └─jmh
    │                          MyBenchmark.java
    │
    └─target
          benchmarks.jar
          jmh-test01-1.0.0.jar
运行以下命令:

java -jar target/benchmarks.jar
这时，我们的基准测试就开始运行了。

D:\growUp\git_repository\java-tools\jmh-demo\jmh-test01>java -jar target/benchmarks.jar
# JMH version: 1.25
# VM version: JDK 1.8.0_231, Java HotSpot(TM) 64-Bit Server VM, 25.231-b11
# VM invoker: D:\growUp\installation\jdk1.8.0_231\jre\bin\java.exe
# VM options: <none>
# Warmup: 5 iterations, 10 s each
# Measurement: 5 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Throughput, ops/time
# Benchmark: cn.zzs.jmh.MyBenchmark.testMethod

# Run progress: 0.00% complete, ETA 00:08:20
# Fork: 1 of 5
# Warmup Iteration   1: 3955731078.669 ops/s
# Warmup Iteration   2: 3910971792.656 ops/s
# Warmup Iteration   3: 3881001464.578 ops/s
# Warmup Iteration   4: 3916172600.571 ops/s
# Warmup Iteration   5: 3956321997.093 ops/s
Iteration   1: 3942596162.384 ops/s
Iteration   2: 3962073081.983 ops/s
Iteration   3: 3956347169.335 ops/s
Iteration   4: 3935835073.222 ops/s
Iteration   5: 3934716909.315 ops/s

# ······

# Run progress: 80.00% complete, ETA 00:01:40
# Fork: 5 of 5
# Warmup Iteration   1: 3398845405.179 ops/s
# Warmup Iteration   2: 3716777120.646 ops/s
# Warmup Iteration   3: 3414803497.798 ops/s
# Warmup Iteration   4: 3621211396.229 ops/s
# Warmup Iteration   5: 3616308570.681 ops/s
Iteration   1: 3898056365.287 ops/s
Iteration   2: 3935143498.460 ops/s
Iteration   3: 3943901632.014 ops/s
Iteration   4: 3906292827.077 ops/s
Iteration   5: 3918607665.065 ops/s


Result "cn.zzs.jmh.MyBenchmark.testMethod":
  3949010528.035 ±(99.9%) 16881035.344 ops/s [Average]
  (min, avg, max) = (3898056365.287, 3949010528.035, 3975167080.768), stdev = 22535699.213
  CI (99.9%): [3932129492.691, 3965891563.378] (assumes normal distribution)

# Run complete. Total time: 00:08:21

Benchmark                Mode  Cnt           Score          Error  Units
MyBenchmark.testMethod  thrpt   25  3949010528.035 ± 16881035.344  ops/s
在头部分打印了MyBenchmark.testMethod这个 Benchmark 方法的配置信息，如下：

# JMH version: 1.25
# VM version: JDK 1.8.0_231, Java HotSpot(TM) 64-Bit Server VM, 25.231-b11
# VM invoker: D:\growUp\installation\jdk1.8.0_231\jre\bin\java.exe
# VM options: <none>  
# Warmup: 5 iterations, 10 s each  ---------------预热5个迭代，每个迭代10s
# Measurement: 5 iterations, 10 s each------------正式测试5个迭代，每个迭代10s
# Timeout: 10 min per iteration-------------------每个迭代的超时时间10min
# Threads: 1 thread, will synchronize iterations--使用1个线程测试
# Benchmark mode: Throughput, ops/time------------使用吞吐量作为测试指标
# Benchmark: cn.zzs.jmh.MyBenchmark.testMethod
在最后打印了这个 Benchmark 方法的测试结果，如下。它的吞吐是 3949010528.035 ± 16881035.344 ops/s。注意，一个 Benchmark 的测试结果是没有意义的，只有多个 Benchmark 对比才可能得出结论。

Benchmark                Mode  Cnt           Score          Error  Units
MyBenchmark.testMethod  thrpt   25  3949010528.035 ± 16881035.344  ops/s
详细配置
通过上面的入门例子简单介绍了如何使用 JMH，接下来将继续对Benchmark 方法的配置 。针对这一点，官方没有给出具体的文档，而是提供了 30 多个示例代码供我们学习JMH Samples 。

这些示例代码并不好读懂，尤其是涉及到 JVM 的部分。其实，只要我们读懂 1-11、20 的例子就行，这些例子已经足够我们日常使用。

至于其他的，大多是介绍 JVM 或者本地机器的某些机制将影响到测试的准确性，以及通过什么方法减少这些影响，非常难懂。本文不会介绍这部分内容，大部分情况下，JMH 已经尽量为我们屏蔽这些因素带来的影响，我们只要使用默认配置就可以。

以下只针对 1-11、20 的例子进行总结和补充。有误的地方，欢迎指正。

在介绍以下内容之前，这里先介绍下一个 Benchmark 方法的组成部分（只是一个大致结果，并不准确），如下。要很好地理解后面的内容，最后掌握这个结构。

//Benchmark
public void Benchmark01(){
    // ······
    // 预热
    // 每个循环为一个iteration
    for(iterations){
        // 每个循环为一个invocation
        while(!timeout){
            // 调用我们的测试方法
        }
    }
    // ······
    // 测试
    // 每个循环为一个iteration
    for(iterations){
        // 每个循环为一个invocation，这里会统计每次invocation的开销
        while(!timeout){
            // 调用我们的测试方法
        }
    }
    // ······
}
@Benchmark
@Benchmark用于告诉 JMH 哪些方法需要进行测试，只能注解在方法上，有点类似 junit 的@Test。在测试项目进行 package 时，JMH 会针对注解了@Benchmark的方法生成 Benchmark 方法代码。

@Benchmark
    public void wellHelloThere() {
        // this method was intentionally left blank.
    }
通常情况下，每个 Benchmark 方法都运行在独立的进程中，互不干涉。

@BenchmarkMode
@BenchmarkMode用于指定当前 Benchmark 方法使用哪种模式测试。JMH 提供了4种不同的模式，用于输出不同的结果指标，如下：

| 模式 | 描述 | 
| -------------- | ------------------------------------------------------------ | 
| Throughput | 吞吐量，ops/time。单位时间内执行操作的平均次数 | 
| AverageTime | 每次操作所需时间，time/op。执行每次操作所需的平均时间 | 
| SampleTime | 同 AverageTime。区别在于 SampleTime 会统计取样 x% 达到了多少 time/op，如下。| 
| SingleShotTime | 同 AverageTime。区别在于 SingleShotTime 只执行一次操作。这种模式的结果存在较大随机性。 |

@BenchmarkMode支持数组，也就是说可以为同一个方法同时指定多种模式，生成基准测试代码时，JMH 将按照不同模式分别生成多个独立的 Benchmark 方法。另外，我们可以使用@OutputTimeUnit来指定时间单位，可以精确到纳秒级别。

/*
     * 使用一种模式
     */
    @Benchmark
    @BenchmarkMode(Mode.Throughput)
    @OutputTimeUnit(TimeUnit.SECONDS)
    public void measureThroughput() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(100);
    }
    /*
     * 使用多种模式
     */
    @Benchmark
    @BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SampleTime, Mode.SingleShotTime})
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public void measureMultiple() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(100);
    }
    /*
     * 使用所有模式
     */
    @Benchmark
    @BenchmarkMode(Mode.All)
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public void measureAll() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(100);
    }
@Warmup和@Measurement
@Warmup 和@Measurement分别用于配置预热迭代和测试迭代。其中，iterations 用于指定迭代次数，time 和 timeUnit 用于每个迭代的时间，batchSize 表示执行多少次 Benchmark 方法为一个 invocation。

@Benchmark
    @Warmup(iterations = 5, time = 100, timeUnit = TimeUnit.MILLISECONDS, batchSize = 10)
    @Measurement(iterations = 5, time = 100, timeUnit = TimeUnit.MILLISECONDS, batchSize = 10)
    public double measure() {
        //······
    }
@State
个人理解，State 就是被注入到 Benchmark 方法中的对象，它的数据和方法可以被 Benchmark 方法使用。在 JMH 中，注解了@State的类在测试项目进行 package 时可以被注入到 Benchmark 方法中。

配置方式
State 的配置方式有两种。

第一种是 Benchmark 不在 State 的类里。这时需要在测试方法的入参列表里显式注入该 State。

public class JMHSample_03_States {

    @State(Scope.Benchmark)
    public static class BenchmarkState {
        volatile double x = Math.PI;
    }

    @State(Scope.Thread)
    public static class ThreadState {
        volatile double x = Math.PI;
    }

    @Benchmark
    public void measureUnshared(ThreadState state) {
        state.x++;
    }

    @Benchmark
    public void measureShared(BenchmarkState state) {
        state.x++;
    }
}
第二种是 Benchmark 在 State 的类里。这时不需要在测试方法的入参列表里显式注入该 State。

@State(Scope.Thread)
public class JMHSample_04_DefaultState {

    double x = Math.PI;

    @Benchmark
    public void measure() {
        x++;
    }

}
Scope
Scope 是@State的属性，用于描述 State 的作用范围，主要有三种：

| scope | 描述 | 
| --------- | ------------------------------------------------------------ | 
| Benchmark | Benchmark 中所有线程都使用同一个 State | 
| Group | Benchmark 中同一 Benchmark 组（使用@Group标识，后面再讲）使用一个 State | 
| Thread | Benchmark 中每个线程使用同一个 State |

@Setup 和 @TearDown
这两个注解只能定义在注解了 State 里，其中，@Setup类似于 junit 的@Before，而@TearDown类似于 junit 的@After。

@State(Scope.Thread)
public class JMHSample_05_StateFixtures {

    double x;

    @Setup(Level.Iteration)
    public void prepare() {
        System.err.println("init............");
        x = Math.PI;
    }

    @TearDown(Level.Iteration)
    public void check() {
        System.err.println("destroy............");
        assert x > Math.PI : "Nothing changed?";
    }


    @Benchmark
    public void measureRight() {
        x++;
    }

}
这两个注解注释的方法的调用时机，主要受 Level 的控制，JMH 提供了三种 Level，如下：

Trial
Benchmark 开始前或结束后执行，如下。Level 为 Benchmark 的 Setup 和 TearDown 方法的开销不会计入到最终结果。

//Benchmark
public void Benchmark01(){
    // call Setup method
    // 每个循环为一个iteration
    for(iterations){
        // 每个循环为一个invocation，这里会统计每次invocation的开销
        while(!timeout){
            // 调用我们的测试方法
        }
    }
    // call TearDown method
}
Iteration
Benchmark 里每个 Iteration 开始前或结束后执行，如下。Level 为 Iteration 的 Setup 和 TearDown 方法的开销不会计入到最终结果。

//Benchmark
public void Benchmark01(){
    // 每个循环为一个iteration
    for(iterations){
        // call Setup method
        // 每个循环为一个invocation，这里会统计每次invocation的开销
        while(!timeout){
            // 调用我们的测试方法
        }
        // call TearDown method
    }
}
Invocation
Iteration 里每次方法调用开始前或结束后执行，如下。Level 为 Invocation 的 Setup 和 TearDown 方法的开销将计入到最终结果。

//Benchmark
public void Benchmark01(){
    // 每个循环为一个iteration
    for(iterations){
        // 每个循环为一个invocation，这里会统计每次invocation的开销
        while(!timeout){
            // call Setup method
            // 调用我们的测试方法
            // call TearDown method
        }
    }
}
以上内容基本可以满足 JMH 的日常使用需求，至于其他示例的内容，后面有空再做补充。
